/*
 * %W% %E%
 *
 * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.corba.se.impl.activation;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Vector;
import java.util.Properties;
import java.util.StringTokenizer;

import org.omg.CORBA.ORB;
import org.omg.CORBA.INITIALIZE;
import org.omg.CORBA.CompletionStatus;
import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.orbutil.CorbaResourceUtil;
import com.sun.corba.se.spi.activation.*;
import com.sun.corba.se.spi.activation.ServerHeldDown;
import com.sun.corba.se.spi.activation.RepositoryPackage.ServerDef;
import com.sun.corba.se.spi.activation.LocatorPackage.ServerLocation;
import com.sun.corba.se.spi.activation.LocatorPackage.ServerLocationPerORB;

/**
 * 
 * @version 	1.7, 97/10/19
 * @author	Anita Jindal
 * @since	JDK1.3
 */
public class ServerTool
{
    final static String helpCommand = "help";
    final static String toolName    = "servertool";
    final static String commandArg  = "-cmd";

    static int getServerIdForAlias( ORB orb, String applicationName ) throws ServerNotRegistered
    {
	try {
	    Repository rep = RepositoryHelper.narrow( 
		orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ) ) ;
	    int serverid = rep.getServerID(applicationName);

	    return rep.getServerID( applicationName ) ;
	} catch (Exception ex) {
	    throw (new ServerNotRegistered());
	}
    }

    void run(String[] args)
    {
	String[] cmd = null;

	// if command specified in the args, get it
	for (int i=0; i < args.length; i++) {

	    if (args[i].equals(commandArg)) {
		// get the command
		int cmdLen = args.length - i - 1;
		cmd = new String[cmdLen];
		for (int j=0; j < cmdLen; j++) cmd[j] = args[++i];

		break;
	    }
	}

	try {
	    // create the POA ORB
	    Properties props = System.getProperties() ;
	    props.put("org.omg.CORBA.ORBClass",  
		"com.sun.corba.se.impl.orb.ORBImpl" );
	    orb = (ORB) ORB.init(args, props);

	    // if command specified in the args, process it
	    if (cmd != null)  executeCommand(cmd);
	    else { // process commands interactively

	        // create a buffered reader to read commands from standard in
	        BufferedReader in = new 
		    BufferedReader(new InputStreamReader(System.in));

	        // print tool banner
	        System.out.println(CorbaResourceUtil.getText("servertool.banner"));

	        // process commands until user quits
	        while (true) {
		    cmd = readCommand(in);
		    if (cmd != null) executeCommand(cmd);
		    else printAvailableCommands();
	        }
	    }
	} catch (Exception ex) {
	    System.out.println(CorbaResourceUtil.getText("servertool.usage", "servertool"));
	    System.out.println();
	    ex.printStackTrace();
	}
    }

    public static void main(String[] args)
    {
	ServerTool tool = new ServerTool();
	tool.run(args);
    }

    String[] readCommand(BufferedReader in)
    {
	System.out.print(toolName + " > ");

	try {
	    int i = 0;
	    String cmd[] = null;

	    String cmdLine = in.readLine();

	    if (cmdLine != null) {
		StringTokenizer st = new StringTokenizer(cmdLine);
		if (st.countTokens() != 0) {
		    cmd = new String[st.countTokens()];
		    while (st.hasMoreTokens()) cmd[i++] = st.nextToken();
		}
	    }

	    return cmd;
	} catch (Exception ex) {
	    System.out.println(CorbaResourceUtil.getText("servertool.usage", "servertool"));
	    System.out.println();
	    ex.printStackTrace();
	}

	return null;
    }

    void printAvailableCommands()
    {
	CommandHandler handler;

	// print short help
	System.out.println(CorbaResourceUtil.getText("servertool.shorthelp"));

	for (int i=0; i < handlers.size(); i++) {
	    handler = (CommandHandler) handlers.elementAt(i);
	    System.out.print("\t" + handler.getCommandName());
	    for (int j=handler.getCommandName().length();
		 j < maxNameLen; j++) System.out.print(" ");
	    System.out.print(" - ");
	    handler.printCommandHelp(System.out, 
				     CommandHandler.shortHelp);
	}

	System.out.println();
    }

    void executeCommand(String[] cmd)
    {
	boolean result;
	CommandHandler handler;

	// handle the help command
	if (cmd[0].equals(helpCommand)) {
	    if (cmd.length == 1) printAvailableCommands();
	    else {
		// print long help for a specific command
		for (int i=0; i < handlers.size(); i++) {
	    	    handler = (CommandHandler) handlers.elementAt(i);
		    if (handler.getCommandName().equals(cmd[1])) {
			handler.printCommandHelp(System.out, 
						 CommandHandler.longHelp);
		    }
		}
	    }

	    return;
	}

	// determine the subcommand and execute it
	for (int i=0; i < handlers.size(); i++) {
	    handler = (CommandHandler) handlers.elementAt(i);
	    if (handler.getCommandName().equals(cmd[0])) {
		String[] cmdArgs = new String[cmd.length - 1];

		// construct args to the command
		for (int j=0; j < cmdArgs.length; j++)
		    cmdArgs[j] = cmd[j+1];

		// execute the command 
		try {
		    System.out.println();

		    result = handler.processCommand(cmdArgs, orb, System.out);

		    if (result == CommandHandler.parseError) {
			handler.printCommandHelp(System.out, 
						 CommandHandler.longHelp);
		    }

		    System.out.println();

		} catch (Exception ex) {}

		return;
	    }
	}

	// unknown command - print available commands
	printAvailableCommands();
    }

    final private static boolean debug = false;

    ORB orb = null;

    static Vector handlers;
    static int maxNameLen;

    static {
	handlers = new Vector();
	handlers.addElement(new RegisterServer());
	handlers.addElement(new UnRegisterServer());
	handlers.addElement(new GetServerID());
	handlers.addElement(new ListServers());
	handlers.addElement(new ListAliases());
	handlers.addElement(new ListActiveServers());
	handlers.addElement(new LocateServer());
	handlers.addElement(new LocateServerForORB());
	handlers.addElement(new ListORBs());
	handlers.addElement(new ShutdownServer());
	handlers.addElement(new StartServer());
	handlers.addElement(new Help());
	handlers.addElement(new Quit());

	// determine longest command name
	maxNameLen = 0;
	int cmdNameLen;
	for (int i=0; i < handlers.size(); i++) {
	    CommandHandler handler = (CommandHandler) handlers.elementAt(i);
	    cmdNameLen = handler.getCommandName().length();
	    if (cmdNameLen > maxNameLen) maxNameLen =  cmdNameLen;
	}
    }
}

class RegisterServer implements CommandHandler
{
    public String getCommandName() {return "register";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.register"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.register1"));
	}
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	int i=0;
	String applicationName = "";
	String name = "";
	String classpath = "";
	String args = "";
	String vmargs = "";
	int serverId = 0;

	// parse register server command
	String arg;
	while (i < cmdArgs.length) {

	    arg = cmdArgs[i++];

	    if (arg.equals("-server")) {
		if (i < cmdArgs.length) name = cmdArgs[i++];
		else return parseError;
	    } else if (arg.equals("-applicationName")) {
		if (i < cmdArgs.length) applicationName = cmdArgs[i++];
		else return parseError;
	    } else if (arg.equals("-classpath")) {
		if (i < cmdArgs.length) classpath = cmdArgs[i++];
		else return parseError;
	    } else if (arg.equals("-args")) {
		while ((i < cmdArgs.length) && !cmdArgs[i].equals("-vmargs")){
		    args = args.equals("") ? cmdArgs[i] : 
			args + " " + cmdArgs[i];
		    i++;
		}
		if (args.equals("")) return parseError;
	    } else if (arg.equals("-vmargs")) {
		while ((i < cmdArgs.length) && !cmdArgs[i].equals("-args")){
		    vmargs = vmargs.equals("") ? cmdArgs[i] : 
			vmargs + " " + cmdArgs[i];
		    i++;
		}
		if (vmargs.equals("")) return parseError;
	    } else return parseError;
	}

	// minimally the server class name has to be specified
	if (name.equals("")) return parseError;

	// register server and activate it
	try {
	    // register the server with the repository
	    Repository repository = RepositoryHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

	    ServerDef server = new ServerDef(applicationName, name, classpath, args, vmargs);
	    serverId = repository.registerServer(server);

	    // activate the server
	    Activator activator = ActivatorHelper.narrow( 
		orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
	    activator.activate(serverId);
	    activator.install(serverId);

	    // print success message
	    out.println(CorbaResourceUtil.getText("servertool.register2", serverId));
	} catch (ServerNotRegistered ex) {
	} catch (ServerAlreadyActive ex) {
	} catch (ServerHeldDown ex) {
	    out.println(CorbaResourceUtil.getText("servertool.register3", serverId));
	} catch (ServerAlreadyRegistered ex) {
	    out.println(CorbaResourceUtil.getText("servertool.register4", serverId));
	} catch (BadServerDefinition ex) {
	    out.println(CorbaResourceUtil.getText("servertool.baddef", ex.reason));
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

	return commandDone;
    }
}

class UnRegisterServer implements CommandHandler
{
    public String getCommandName() {return "unregister";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.unregister"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.unregister1"));
	}
}

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	int serverId = illegalServerId;

	try {
	    if (cmdArgs.length == 2) {
	        if (cmdArgs[0].equals("-serverid"))
		    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
	        else if (cmdArgs[0].equals("-applicationName"))
		    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;
	    }

	    // the server id has to be specified
	    if (serverId == illegalServerId) 
	        return parseError;

	    // deactivate server, hold it down and and unregister it
	    // deactivate the server
	    try {
	        Activator activator = ActivatorHelper.narrow(
		     orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
	        activator.uninstall(serverId);
	    } catch (ServerHeldDown ex) {}

	    // unregister the server from the repository
	    Repository repository = RepositoryHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));
	    repository.unregisterServer(serverId);

	    // print success message
	    out.println(CorbaResourceUtil.getText("servertool.unregister2"));
        } catch (ServerNotRegistered ex) {
	    out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
        } catch (Exception ex) {
	    ex.printStackTrace();
	}

        return commandDone;
    }
}

class LocateServer implements CommandHandler
{
    public String getCommandName() {return "locate";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.locate"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.locate1"));
	}
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	int serverId = illegalServerId;

	String endPointType = IIOP_CLEAR_TEXT.value;
	try {

            // parse command
            String arg;
	    int i = 0;
            while (i < cmdArgs.length) {

                arg = cmdArgs[i++];

                if (arg.equals("-serverid")) {
                    if (i < cmdArgs.length) 
		        serverId = (Integer.valueOf(cmdArgs[i++])).intValue();
                    else 
                        return parseError;
                } else if (arg.equals("-applicationName")) {
                    if (i < cmdArgs.length) 
		        serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[i++] ) ;
                    else 
                        return parseError;
	        } else if (arg.equals("-endpointType")) {
		    if (i < cmdArgs.length)
	                endPointType = cmdArgs[i++];
	        }
            }

	    // the server id has to be specified
	    if (serverId == illegalServerId) 
	        return parseError;

	    // locate the server
	    // deactivate the server
	    Locator locator = LocatorHelper.narrow(
	        orb.resolve_initial_references( ORBConstants.SERVER_LOCATOR_NAME ));
	     
	    ServerLocation location = locator.locateServer(serverId, endPointType);

	    // print success message
	    out.println(CorbaResourceUtil.getText("servertool.locate2", location.hostname));
	    int numEntries = location.ports.length;
	    for (i = 0; i < numEntries; i++) { 
	        ORBPortInfo orbPort = location.ports[i];
	        out.println("\t\t"+ orbPort.port + "\t\t" + endPointType + "\t\t" + orbPort.orbId );
	    }
	} catch (NoSuchEndPoint ex) {
	} catch (ServerHeldDown ex) {
	    out.println(CorbaResourceUtil.getText("servertool.helddown"));
	} catch (ServerNotRegistered ex) {
	    out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

	return commandDone;
    }
}

class LocateServerForORB implements CommandHandler
{
    public String getCommandName() {return "locateperorb";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.locateorb"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.locateorb1"));
	}
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	int serverId = illegalServerId;

	String orbId = "";
	try {

            // parse command
            String arg;
	    int i = 0;
            while (i < cmdArgs.length) {

                arg = cmdArgs[i++];

                if (arg.equals("-serverid")) {
                    if (i < cmdArgs.length) 
		        serverId = (Integer.valueOf(cmdArgs[i++])).intValue();
                    else 
                        return parseError;
                } else if (arg.equals("-applicationName")) {
                    if (i < cmdArgs.length) 
		        serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[i++] ) ;
                    else 
                        return parseError;
	        } else if (arg.equals("-orbid")) {
		    if (i < cmdArgs.length)
	                orbId = cmdArgs[i++];
	        }
            }

	    // the server id has to be specified
	    if (serverId == illegalServerId) 
	        return parseError;

	    // locate the server
	    // deactivate the server
	    Locator locator = LocatorHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_LOCATOR_NAME ));

	    ServerLocationPerORB location = locator.locateServerForORB(serverId, 
					    orbId);

	    // print success message
	    out.println(CorbaResourceUtil.getText("servertool.locateorb2", location.hostname));
	    int numEntries = location.ports.length;
	    for (i = 0; i < numEntries; i++) { 
	        EndPointInfo Port = location.ports[i];
	        out.println("\t\t"+ Port.port + "\t\t" + Port.endpointType + "\t\t" + orbId );
	    }
	} catch (InvalidORBid ex) {
	    out.println(CorbaResourceUtil.getText("servertool.nosuchorb"));
	} catch (ServerHeldDown ex) {
	    out.println(CorbaResourceUtil.getText("servertool.helddown"));
	} catch (ServerNotRegistered ex) {
	    out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

	return commandDone;
    }
}

class GetServerID implements CommandHandler
{
    public String getCommandName() {return "getserverid" ; }

    public void printCommandHelp( PrintStream out, boolean helpType )
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.getserverid"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.getserverid1"));
	}
    }

    public boolean processCommand( String[] cmdArgs, ORB orb, PrintStream out )
    {
	if ((cmdArgs.length == 2) && cmdArgs[0].equals( "-applicationName" )) {
	    String str = (String)cmdArgs[1] ;

	    try {
		Repository repository = RepositoryHelper.narrow(
		    orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

		try {
		    int result = repository.getServerID( str ) ;
		    out.println() ;
	            out.println(CorbaResourceUtil.getText("servertool.getserverid2", str, Integer.toString(result)));
		    out.println() ;
		} catch (ServerNotRegistered e) {
	            out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
		}
	    } catch (Exception ex) {
		ex.printStackTrace() ;
	    }

	    return commandDone ;
	} else
	    return parseError ;
    }
}

class ListServers implements CommandHandler
{
    public String getCommandName() {return "list";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.list"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.list1"));
	}
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	int serverId = illegalServerId;
	boolean listOneServer = false;
	ServerDef serverDef;

	// determine if list single server or all servers
	listOneServer = (cmdArgs.length!=0) ;
	if ((cmdArgs.length == 2) && cmdArgs[0].equals("-serverid")) 
	    serverId = (Integer.valueOf(cmdArgs[1])).intValue();

	if ((serverId == illegalServerId) && listOneServer)
	    return parseError;

	// process the list server command
	try {
	    Repository repository = RepositoryHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

	    if (listOneServer) {

		try {
		    serverDef = repository.getServer(serverId);
		    out.println();
		    printServerDef(serverDef, serverId, out);
		    out.println();
		} catch (ServerNotRegistered e) {
	            out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
		}

	    } else {
		int[] servers = repository.listRegisteredServers();
	        out.println(CorbaResourceUtil.getText("servertool.list2"));

		sortServers(servers);
		for (int i=0; i < servers.length; i++) {
		    try {
		        serverDef = repository.getServer(servers[i]);
			out.println("\t   " + servers[i] + "\t\t" + 
				    serverDef.serverName + "\t\t" 
				    + serverDef.applicationName);
		    } catch (ServerNotRegistered e) {}
		}

	    }
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

	return commandDone;
    }

static void printServerDef(ServerDef serverDef, int serverId, 
			   PrintStream out)
{
    out.println(CorbaResourceUtil.getText("servertool.appname", serverDef.applicationName));
    out.println(CorbaResourceUtil.getText("servertool.name", serverDef.serverName));
    out.println(CorbaResourceUtil.getText("servertool.classpath", serverDef.serverClassPath));
    out.println(CorbaResourceUtil.getText("servertool.args", serverDef.serverArgs));
    out.println(CorbaResourceUtil.getText("servertool.vmargs", serverDef.serverVmArgs));
    out.println(CorbaResourceUtil.getText("servertool.serverid", serverId));
}

/** 
 * Do a simple bubble sort to sort the server ids in ascending
 * order.
 */
static void sortServers(int[] serverIds)
{
    int size = serverIds.length;
    int lowest;

    for (int i=0; i < size; i++) {

	lowest = i;

	for (int j=i+1; j < size; j++) {
	    if (serverIds[j] < serverIds[lowest]) lowest = j;
	}

	if (lowest != i) {
	    int temp = serverIds[i];
	    serverIds[i] = serverIds[lowest];
	    serverIds[lowest] = temp;
	}
    }
}
}

class ListActiveServers implements CommandHandler
{
    public String getCommandName() {return "listactive";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.listactive"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.listactive1"));
	}
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	ServerDef serverDef;

	// process the list active servers command
	try {
	    Repository repository = RepositoryHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

	    Activator activator = ActivatorHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
	    
	    int[] servers = activator.getActiveServers();

	    out.println(CorbaResourceUtil.getText("servertool.list2"));

	    ListServers.sortServers(servers);
	    for (int i=0; i < servers.length; i++) {
	        try {
	            serverDef = repository.getServer(servers[i]);
		    out.println("\t   " + servers[i] + "\t\t" + 
				serverDef.serverName + "\t\t" + 
				serverDef.applicationName);
	    	} catch (ServerNotRegistered e) {}
	    }
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

	return commandDone;
    }
}

class ListAliases implements CommandHandler
{
    public String getCommandName() {return "listappnames";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.listappnames"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.listappnames1"));
	}
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	try {
	    Repository repository = RepositoryHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

	    String[] applicationNames = repository.getApplicationNames();

	    out.println(CorbaResourceUtil.getText("servertool.listappnames2"));
	    out.println();
	    for (int i=0; i < applicationNames.length; i++) 
		out.println( "\t" + applicationNames[i] ) ;
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

	return commandDone;
    }
}

class ShutdownServer implements CommandHandler
{
    public String getCommandName() {return "shutdown";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.shutdown"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.shutdown1"));
	}
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	int serverId = illegalServerId;

	try {
	    // determine the server id
	    if (cmdArgs.length == 2) 
	        if (cmdArgs[0].equals("-serverid")) 
		    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
	        else if (cmdArgs[0].equals("-applicationName"))
		    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;

	    if (serverId == illegalServerId) 
	        return parseError;

	    // shutdown the server
	    Activator activator = ActivatorHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
	    activator.shutdown(serverId);

	    out.println(CorbaResourceUtil.getText("servertool.shutdown2"));
	} catch (ServerNotActive ex) {
	    out.println(CorbaResourceUtil.getText("servertool.servernotrunning"));
        } catch (ServerNotRegistered ex) {
	    out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

	return commandDone;
    }
}

class StartServer implements CommandHandler
{
    public String getCommandName() {return "startup";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.startserver"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.startserver1"));
	}
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	int serverId = illegalServerId;

	try {
	    // determine the server id
	    if (cmdArgs.length == 2) 
	        if (cmdArgs[0].equals("-serverid"))
		    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
	        else if (cmdArgs[0].equals("-applicationName"))
		    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;

	    if (serverId == illegalServerId) 
	        return parseError;

	    // startup the server
	    Activator activator = ActivatorHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
	    activator.activate(serverId);

	    out.println(CorbaResourceUtil.getText("servertool.startserver2"));
	} catch (ServerNotRegistered ex) {
	    out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
	} catch (ServerAlreadyActive ex) {
	    out.println(CorbaResourceUtil.getText("servertool.serverup"));
	} catch (ServerHeldDown ex) {
	    out.println(CorbaResourceUtil.getText("servertool.helddown"));
	} catch (Exception ex) {
	    ex.printStackTrace();
        }
	return commandDone;
    }
}

class Quit implements CommandHandler
{
    public String getCommandName() {return "quit";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.quit"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.quit1"));
	}
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	System.exit(0);

	return commandDone;
    }
}

class Help implements CommandHandler
{
    public String getCommandName() {return "help";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.help"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.help1"));
	}
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
	return commandDone;
    }
}

class ListORBs implements CommandHandler
{
    public String getCommandName() {return "orblist";}
   
    public void printCommandHelp(PrintStream out, boolean helpType)
    {
	if (helpType == longHelp) {
	    out.println(CorbaResourceUtil.getText("servertool.orbidmap"));
	} else {
	    out.println(CorbaResourceUtil.getText("servertool.orbidmap1"));
	}
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {

	int serverId = illegalServerId;

	try {
	    if (cmdArgs.length == 2) {
	        if (cmdArgs[0].equals("-serverid"))
		    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
	        else if (cmdArgs[0].equals("-applicationName"))
		    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;
	    }

	    // the server id has to be specified
	    if (serverId == illegalServerId) 
	        return parseError;
            // activate the server
            Activator activator = ActivatorHelper.narrow(
		orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));

	    String[] orbList = activator.getORBNames(serverId);

	    out.println(CorbaResourceUtil.getText("servertool.orbidmap2"));

	    for (int i = 0;  i < orbList.length ; i++) {
   		out.println("\t "+ orbList[i]);
	    }
        } catch (ServerNotRegistered ex) {
	    out.println("\tno such server found.");
	} catch (Exception ex) {
	    ex.printStackTrace();
	}

      return commandDone;
    }
}
